home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 17 / CU Amiga Magazine's Super CD-ROM 17 (1997)(EMAP Images)(GB)[!][issue 1997-12].iso / CUCD / Programming / DiceSource / src / dd / lists.c < prev    next >
C/C++ Source or Header  |  1997-09-09  |  25KB  |  680 lines
  1. /*
  2.  *    (c)Copyright 1992-1997 Obvious Implementations Corp.  Redistribution and
  3.  *    use is allowed under the terms of the DICE-LICENSE FILE,
  4.  *    DICE-LICENSE.TXT.
  5.  */
  6. #include    "defs.h"
  7. #include    "dbug_protos.h"
  8. #include    <lists.h>
  9. #include    <lib/misc.h>
  10.  
  11. Prototype void    FreeDLIST(LIST *list);
  12. Prototype BOOL    AddListNODE(LIST *list, UBYTE type, char *data);
  13. Prototype BOOL    DownList(void);
  14. Prototype BOOL    UpList(void);
  15. Prototype BOOL    PageDownList(void);
  16. Prototype BOOL    PageUpList(void);
  17. Prototype WORD    RefreshList(WORD maxLines, BOOL fullRefresh, LONG top);
  18. Prototype BOOL    SprintfDLIST(LIST *list, UBYTE type, char *fmt, ...);
  19. Local unsigned int _swrite(char *buf, size_t n1, size_t n2, const char **sst);
  20.  
  21. Prototype void    ListDosBase(DBugDisp *dp);
  22. Prototype void    ListProcess(DBugDisp *dp);
  23.  
  24. Prototype void    ListInfo(DBugDisp *dp);
  25. Prototype void    ListExecBase(DBugDisp *dp);
  26. Prototype void    BuildDLIST(LIST *dst, LIST *src, ULONG type);
  27. Prototype void    ListResources(DBugDisp *dp);
  28. Prototype void    ListIntrs(DBugDisp *dp);
  29. Prototype void    ListPorts(DBugDisp *dp);
  30. Prototype void    ListTasks(DBugDisp *dp);
  31. Prototype void    ListLibs(DBugDisp *dp);
  32. Prototype void    ListDevices(DBugDisp *dp);
  33. Prototype void    ListMemList(DBugDisp *dp);
  34. Prototype int     SizeDLIST(LIST *list);
  35. Prototype BOOL    ListSymbols(DBugDisp *dp);
  36.  
  37. // ************************************************************************
  38.  
  39. int SizeDLIST(LIST *list) {
  40.     DLIST    *dp;
  41.     int i=0;
  42.  
  43.     for (dp = GetHead(&CurDisplay->ds_List); dp; 
  44.         dp = GetSucc(&dp->node)) {
  45.         ++i;
  46.     }
  47.     return i;
  48. }
  49.  
  50. void    FreeDLIST(LIST *list) {
  51.     LIST *lp;
  52.  
  53.     while (lp = RemHead(list)) Free(lp);
  54.     NewList(list);
  55. }
  56.  
  57.  
  58. BOOL    AddListNODE(LIST *list, UBYTE type, char *name) {
  59.     WORD    len = strlen(name);
  60.     DLIST    *dp = (DLIST *)MallocPublic(sizeof(DLIST)+len+1);
  61.  
  62.     if (GetHead(list) == NULL)
  63.         CurDisplay->ds_WindowTop = 0;
  64.  
  65.     if (dp) {
  66.         dp->node.ln_Name = (char *)&dp->name[0];
  67.         strcpy(dp->name, name);
  68.         dp->node.ln_Type = type;
  69.         AddTail(list, (NODE *)dp);
  70.         return TRUE;
  71.     }
  72.     return FALSE;
  73. }
  74.  
  75. // ************************************************************************
  76.  
  77. BOOL    DownList(void) {
  78.  
  79.     ++CurDisplay->ds_WindowTop;
  80.     ++CurDisplay->ds_WindowBot;
  81.     ScrScrollup();
  82.     RefreshList(1, -1, CurDisplay->ds_WindowBot);
  83.     return TRUE;
  84. }
  85.  
  86. BOOL    UpList(void)
  87. {
  88.     if (CurDisplay->ds_WindowTop) {
  89.         --CurDisplay->ds_WindowTop;
  90.         --CurDisplay->ds_WindowBot;
  91.         ScrScrolldown();
  92.         RefreshList(1, -1, CurDisplay->ds_WindowTop);
  93.         return TRUE;
  94.     }
  95.     return FALSE;
  96. }
  97.  
  98. BOOL    PageUpList(void)
  99. {
  100.     int lines = CalcDisplayLines();
  101.  
  102.     if ((LONG)CurDisplay->ds_WindowTop > 0) {
  103.     if(lines > 0) {
  104.         CurDisplay->ds_WindowTop -= lines;
  105.         if((LONG)CurDisplay->ds_WindowTop < 0)CurDisplay->ds_WindowTop = 0;
  106.         CurDisplay->ds_WindowBot -= lines;
  107.         if((LONG)CurDisplay->ds_WindowBot < 0)CurDisplay->ds_WindowBot = 0;
  108.     }
  109.     RefreshWindow(1);
  110.     }
  111. }
  112.  
  113. BOOL    PageDownList(void)
  114. {
  115.     int lines = CalcDisplayLines();
  116.  
  117.     if(lines > 0) {
  118.         CurDisplay->ds_WindowTop += lines;
  119.         CurDisplay->ds_WindowBot += lines;
  120.     }
  121.     RefreshWindow(1);
  122. }
  123.  
  124. WORD    RefreshList(WORD maxLines, BOOL fullRefresh, LONG line) {
  125.     DLIST    *dp;
  126.     LONG trackLine = line;
  127.     WORD count = 0;
  128.  
  129.     do_scroller();
  130.     if (fullRefresh != -1) {
  131.         if (dp = GetHead(&CurDisplay->ds_List)) {
  132.         SetTitle(dp->name,NULL);
  133. #if 0
  134.         ScrPlain();
  135.         ScrInverse();
  136.         ScrPuts(dp->name);
  137.         ScrPlain();
  138. #endif
  139.         if(CurDisplay->ds_RegFlag) {
  140.             ++count;
  141.             Newline();
  142.             if (--maxLines == 0)return count;
  143.         }
  144.         }
  145.     }
  146.     for (dp = GetHead(&CurDisplay->ds_List); dp && line; dp = GetSucc(&dp->node)) {
  147.         --line;
  148.     }
  149.     while (dp && maxLines) {
  150.         ScrPuts(dp->name);
  151.         ScrPutNewline();
  152.         dp = GetSucc(&dp->node);
  153.         --maxLines;
  154.         ++trackLine;
  155.         ++count;
  156.     }
  157.     while (maxLines > 0) {
  158.         ScrPutNewline();
  159.         --maxLines;
  160.         ++count;
  161.     }
  162.     if (fullRefresh > 0) {
  163.         CurDisplay->ds_WindowBot = trackLine-1;
  164.     }
  165.     return (count);
  166. }
  167.  
  168. // ************************************************************************
  169.  
  170. Local unsigned int _swrite(char *buf, size_t n1, size_t n2, const char **sst) {
  171.     size_t n;
  172.  
  173.     if (n1 == 1)
  174.         n = n2;
  175.     else if (n2 == 1)
  176.         n = n1;
  177.         else
  178.         n = n1 * n2;
  179.  
  180.     _slow_bcopy(buf, *sst, n);
  181.     *sst += n;
  182.     return(n2);
  183. }
  184.  
  185. BOOL    SprintfDLIST(LIST *list, UBYTE type, char *fmt, ...) {
  186.     char        buf[128];
  187.     char        *ptr = &buf[0];
  188.     va_list     va;
  189.     WORD        n;
  190.  
  191.     va_start(va, fmt);
  192.     n = (WORD)_pfmt(fmt, va, _swrite, &ptr);
  193.     *ptr = 0;
  194.     va_end(va);
  195.     return AddListNODE(list, type, buf);
  196. }
  197.  
  198. /************************************************************************/
  199.  
  200. void    ListDosBase(DBugDisp *dp) {
  201.     LIST                *lp = &dp->ds_List;
  202.     struct DosLibrary        *d = DOSBase;
  203.     struct RootNode         *rn = d->dl_Root;
  204.  
  205.     FreeDLIST(lp);
  206.     SetDisplayMode(DISPLAY_DOSBASE,0);
  207.     SprintfDLIST(lp, DTYPE_DOSBASE, "struct DOSBase:");
  208.     SprintfDLIST(lp, DTYPE_DOSBASE, " dl_Root = %08X ; Pointer to RootNode, described below", d->dl_Root);
  209.     SprintfDLIST(lp, DTYPE_DOSBASE, " dl_GV   = %08X ; Pointer to BCPL global vector", d->dl_GV);
  210.     SprintfDLIST(lp, DTYPE_DOSBASE, " dl_A2   = %08X ; Private register dump of DOS", d->dl_A2);
  211.     SprintfDLIST(lp, DTYPE_DOSBASE, " dl_A5   = %08X", d->dl_A5);
  212.     SprintfDLIST(lp, DTYPE_DOSBASE, " dl_A6   = %08X", d->dl_A6);
  213.  
  214.     SprintfDLIST(lp, DTYPE_DOSBASE, "");
  215.     SprintfDLIST(lp, DTYPE_DOSBASE, "struct RootNode:");
  216.     SprintfDLIST(lp, DTYPE_DOSBASE, " rn_TaskArray          = %08X ; [0] is max number of CLI's", BADDR(rn->rn_TaskArray));
  217.     SprintfDLIST(lp, DTYPE_DOSBASE, "                                  ; [1] is APTR to APROCESS id of CLI 1");
  218.     SprintfDLIST(lp, DTYPE_DOSBASE, "                                  ; [n] is APTR to APROCESS id of CLI n");
  219.     SprintfDLIST(lp, DTYPE_DOSBASE, " rn_ConsoleSegment     = %08X ; SegList for the CLI", BADDR(rn->rn_ConsoleSegment));
  220. #if 0
  221.     struct  DateStamp rn_Time; ; Current time
  222. #endif
  223.     SprintfDLIST(lp, DTYPE_DOSBASE, " rn_RestartSeg         = %08X ; SegList for the disk validator APROCESS", rn->rn_RestartSeg);
  224.     SprintfDLIST(lp, DTYPE_DOSBASE, " rn_Info               = %08X ; Pointer to the Info structure", BADDR(rn->rn_Info));
  225.     SprintfDLIST(lp, DTYPE_DOSBASE, " rn_FileHandlerSegment = %08X ; segment for a file handler", BADDR(rn->rn_FileHandlerSegment));
  226. #if 0
  227.     struct MinList rn_CliList; ; new list of all CLI PROCESSes
  228.                    ; the first cpl_Array is also rn_TaskArray
  229. #endif
  230.     SprintfDLIST(lp, DTYPE_DOSBASE, " rn_BootProc           = %08X ; private ptr to msgport of boot fs", rn->rn_BootProc);
  231.     SprintfDLIST(lp, DTYPE_DOSBASE, " rn_ShellSegment       = %08X ; seglist for Shell (for NewShell)       ", BADDR(rn->rn_ShellSegment));
  232.     SprintfDLIST(lp, DTYPE_DOSBASE, " rn_Flags              = %08X ; dos flags", rn->rn_Flags);
  233. }
  234.  
  235. void    ListProcess(DBugDisp *dp) {
  236.     APROCESS    *p = (APROCESS *)FindTask(NULL);
  237.     LIST        *lp = &dp->ds_List;
  238.  
  239.     FreeDLIST(lp);
  240.     SetDisplayMode(DISPLAY_PROCESS,0);
  241.     SprintfDLIST(lp, DTYPE_PROCESS, "struct APROCESS @$%08X:", p);
  242.     SprintfDLIST(lp, DTYPE_PROCESS, " pr_SegList        = %08X ; Array of seg lists for this APROCESS", BADDR(p->pr_SegList));
  243.     SprintfDLIST(lp, DTYPE_PROCESS, " pr_StackSize      = %08X ; APROCESS stack size in bytes", p->pr_StackSize);
  244.     SprintfDLIST(lp, DTYPE_PROCESS, " pr_GlobVec        = %08X ; Global vector for this APROCESS (BCPL)", p->pr_GlobVec);
  245.     SprintfDLIST(lp, DTYPE_PROCESS, " pr_TaskNum        = %08X ; CLI task number, zero if not a CLI", p->pr_TaskNum);
  246.     SprintfDLIST(lp, DTYPE_PROCESS, " pr_StackBase      = %08X ; High memory end of APROCESS stack", BADDR(p->pr_StackBase));
  247.     SprintfDLIST(lp, DTYPE_PROCESS, " pr_Result2        = %08X ; Secondary result from last call", p->pr_Result2);
  248.     SprintfDLIST(lp, DTYPE_PROCESS, " pr_CurrentDir     = %08X ; Lock on current directory", BADDR(p->pr_CurrentDir));
  249.     SprintfDLIST(lp, DTYPE_PROCESS, " pr_CIS            = %08X ; Current CLI Input Stream", BADDR(p->pr_CIS));
  250.     SprintfDLIST(lp, DTYPE_PROCESS, " pr_COS            = %08X ; Current CLI Output Stream", BADDR(p->pr_COS));
  251.     SprintfDLIST(lp, DTYPE_PROCESS, " pr_ConsoleTask    = %08X ; Console handler APROCESS", p->pr_ConsoleTask);
  252.     SprintfDLIST(lp, DTYPE_PROCESS, " pr_FileSystemTask = %08X ; File handler APROCESS for current drive", p->pr_FileSystemTask);
  253.     SprintfDLIST(lp, DTYPE_PROCESS, " pr_CLI            = %08X ; pointer to CommandLineInterface", BADDR(p->pr_CLI));
  254.     SprintfDLIST(lp, DTYPE_PROCESS, " pr_ReturnAddr     = %08X ; pointer to previous stack frame", p->pr_ReturnAddr);
  255.     SprintfDLIST(lp, DTYPE_PROCESS, " pr_PktWait        = %08X ; To be called when awaiting msg", p->pr_PktWait);
  256.     SprintfDLIST(lp, DTYPE_PROCESS, " pr_WindowPtr      = %08X ; Window for error printing", p->pr_WindowPtr);
  257.     SprintfDLIST(lp, DTYPE_PROCESS, " pr_HomeDir        = %08X ; Home directory of program", BADDR(p->pr_HomeDir));
  258.     SprintfDLIST(lp, DTYPE_PROCESS, " pr_Flags          = %08X ; Flags telling dos about APROCESS", p->pr_Flags);
  259.     SprintfDLIST(lp, DTYPE_PROCESS, " pr_ExitCode       = %08X ; Code to call on exit of program or NULL", p->pr_ExitCode);
  260.     SprintfDLIST(lp, DTYPE_PROCESS, " pr_ExitData       = %08X ; Passed as an argument to pr_ExitCode", p->pr_ExitData);
  261.     SprintfDLIST(lp, DTYPE_PROCESS, " pr_Arguments      = %08X ; Arguments passed to APROCESS at start", p->pr_Arguments);
  262. #if 0
  263.     struct MinList pr_LocalVars; ; Local environment variables
  264. #endif
  265.     SprintfDLIST(lp, DTYPE_PROCESS, " pr_ShellPrivate   = %08X ; for the use of the current shell", p->pr_ShellPrivate);
  266.     SprintfDLIST(lp, DTYPE_PROCESS, " pr_CES            = %08X ; Error stream - if NULL, use pr_COS", BADDR(p->pr_CES));
  267. }
  268.  
  269. /************************************************************************/
  270.  
  271. /* EXEC */
  272.  
  273. void    ListInfo(DBugDisp *dp) {
  274.     LIST        *lp = &dp->ds_List;
  275.     struct Task    *t = SysBase->ThisTask;
  276.  
  277.     FreeDLIST(&dp->ds_List);
  278.     SetDisplayMode(DISPLAY_INFO,0);
  279.     SprintfDLIST(&dp->ds_List, DTYPE_INFO, "Task Structure");
  280.     SprintfDLIST(&dp->ds_List, DTYPE_INFO, " tc_Flags      = %02X      ", (UBYTE)t->tc_Flags);
  281.     SprintfDLIST(&dp->ds_List, DTYPE_INFO, " tc_State      = %02X      ", (UBYTE)t->tc_State);
  282.     SprintfDLIST(&dp->ds_List, DTYPE_INFO, " tc_IDNestCnt  = %02X       ; intr disabled nesting", (UBYTE)t->tc_IDNestCnt);
  283.     SprintfDLIST(&dp->ds_List, DTYPE_INFO, " tc_TDNestCnt  = %02X       ; task disabled nesting", (UBYTE)t->tc_TDNestCnt);
  284.     SprintfDLIST(&dp->ds_List, DTYPE_INFO, " tc_SigAlloc   = %08X ; sigs allocated", t->tc_SigAlloc);
  285.     SprintfDLIST(&dp->ds_List, DTYPE_INFO, " tc_SigWait    = %08X ; sigs we are waiting for", t->tc_SigWait);
  286.     SprintfDLIST(&dp->ds_List, DTYPE_INFO, " tc_SigRecvd   = %08X ; sigs we have received", t->tc_SigRecvd);
  287.     SprintfDLIST(&dp->ds_List, DTYPE_INFO, " tc_SigExcept  = %08X ; sigs we will take excepts for", t->tc_SigExcept);
  288.     SprintfDLIST(&dp->ds_List, DTYPE_INFO, " tc_TrapAlloc  = %04X     ; traps allocated", t->tc_TrapAlloc);
  289.     SprintfDLIST(&dp->ds_List, DTYPE_INFO, " tc_TrapAble   = %04X     ; traps enabled", t->tc_TrapAble);
  290.     SprintfDLIST(&dp->ds_List, DTYPE_INFO, " tc_ExceptData = %08X ; points to except data", t->tc_ExceptData);
  291.     SprintfDLIST(&dp->ds_List, DTYPE_INFO, " tc_ExceptCode = %08X ; points to except code", t->tc_ExceptCode);
  292.     SprintfDLIST(&dp->ds_List, DTYPE_INFO, " tc_TrapData   = %08X ; points to trap data", t->tc_TrapData);
  293.     SprintfDLIST(&dp->ds_List, DTYPE_INFO, " tc_TrapCode   = %08X ; points to trap code", t->tc_TrapCode);
  294.     SprintfDLIST(&dp->ds_List, DTYPE_INFO, " tc_SPReg      = %08X ; stack pointer", t->tc_SPReg);
  295.     SprintfDLIST(&dp->ds_List, DTYPE_INFO, " tc_SPLower    = %08X ; stack lower bound", t->tc_SPLower);
  296.     SprintfDLIST(&dp->ds_List, DTYPE_INFO, " tc_SPUpper    = %08X ; stack upper bound + 2", t->tc_SPUpper);
  297.     SprintfDLIST(&dp->ds_List, DTYPE_INFO, " tc_Switch     = %08X ; task losing CPU", t->tc_Switch);
  298.     SprintfDLIST(&dp->ds_List, DTYPE_INFO, " tc_Launch     = %08X ; task getting CPU", t->tc_Launch);
  299.     SprintfDLIST(&dp->ds_List, DTYPE_INFO, " tc_MemEntry   = %08X ; Allocated memory. Freed by RemTask()", t->tc_MemEntry);
  300.     SprintfDLIST(&dp->ds_List, DTYPE_INFO, " tc_UserData   = %08X ; For use by the task; no restrictions!");
  301.  
  302.     SprintfDLIST(&dp->ds_List, DTYPE_INFO, "");
  303. //    SprintfDLIST(&dp->ds_List, DTYPE_INFO, "Command Line: '%s'", currentContext->commandLine);
  304. //    SprintfDLIST(&dp->ds_List, DTYPE_INFO, "Program is %d segments", currentContext->segCount);
  305. }
  306.  
  307. /************************************************************************/
  308.  
  309. void    ListExecBase(DBugDisp *dp) {
  310.     LIST        *lp = &dp->ds_List;
  311.     struct ExecBase *s = SysBase;
  312.  
  313.     FreeDLIST(&dp->ds_List);
  314.     SetDisplayMode(DISPLAY_EXECBASE,0);
  315.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "struct ExecBase:");
  316.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "SoftVer              =     %04X ; kickstart release number (obs.)", s->SoftVer);
  317.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "LowMemChkSum         =     %04X ; checksum of 68000 trap vectors", s->LowMemChkSum);
  318.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "ChkBase              = %08X ; system base pointer complement", s->ChkBase);
  319.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "ColdCapture          = %08X ; coldstart soft capture vector", s->ColdCapture);
  320.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "CoolCapture          = %08X ; coolstart soft capture vector", s->CoolCapture);
  321.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "WarmCapture          = %08X ; warmstart soft capture vector", s->WarmCapture);
  322.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "SysStkUpper          = %08X ; system stack base   (upper bound)", s->SysStkUpper);
  323.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "SysStkLower          = %08X ; top of system stack (lower bound)", s->SysStkLower);
  324.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "MaxLocMem            = %08X ; top of chip memory", s->MaxLocMem);
  325.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "DebugEntry           = %08X ; global debugger entry point", s->DebugEntry);
  326.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "DebugData            = %08X ; global debugger data segment", s->DebugData);
  327.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "AlertData            = %08X ; alert data segment", s->AlertData);
  328.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "MaxExtMem            = %08X ; top of extended mem, or null if none", s->MaxExtMem);
  329.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "ChkSum               =     %04X ; for all of the above (minus 2)", s->ChkSum);
  330.  
  331. #if 0
  332.     struct    IntVector IntVects[16];
  333. #endif
  334.  
  335.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "ThisTask             = %08X ; pointer to current task (readable)", s->ThisTask);
  336.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "IdleCount            = %08X ; idle counter", s->IdleCount);
  337.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "DispCount            = %08X ; dispatch counter", s->DispCount);
  338.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "Quantum              =     %04X ; time slice quantum", s->Quantum);
  339.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "Elapsed              =     %04X ; current quantum ticks", s->Elapsed);
  340.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "SysFlags             =     %04X ; misc internal system flags", s->SysFlags);
  341.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "IDNestCnt            =       %02X ; interrupt disable nesting count", (UBYTE)s->IDNestCnt);
  342.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "TDNestCnt            =       %02X ; task disable nesting count", (UBYTE)s->TDNestCnt);
  343.  
  344.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "AttnFlags            =     %04X ; special attention flags (readable)", s->AttnFlags);
  345.  
  346.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "AttnResched          =     %04X ; rescheduling attention", s->AttnResched);
  347.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "ResModules           = %08X ; resident module array pointer", s->ResModules);
  348.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "TaskTrapCode         = %08X", s->TaskTrapCode);
  349.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "TaskExceptCode       = %08X", s->TaskExceptCode);
  350.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "TaskExitCode         = %08X", s->TaskExitCode);
  351.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "TaskSigAlloc         = %08X", s->TaskSigAlloc);
  352.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "TaskTrapAlloc        =     %04X ; System Lists (private!)", s->TaskTrapAlloc);
  353.  
  354. #if 0
  355.     struct    List MemList;
  356.     struct    List ResourceList;
  357.     struct    List DeviceList;
  358.     struct    List IntrList;
  359.     struct    List LibList;
  360.     struct    List PortList;
  361.     struct    List TaskReady;
  362.     struct    List TaskWait;
  363. #endif
  364.  
  365. #if 0
  366.     struct    SoftIntList SoftInts[5];
  367. #endif
  368.  
  369. #if 0
  370.     LONG    LastAlert[4];
  371. #endif
  372.  
  373.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "VBlankFrequency      =       %02X ; (readable)", (UBYTE)s->VBlankFrequency);
  374.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "PowerSupplyFrequency =       %02X ; (readable)", (UBYTE)s->PowerSupplyFrequency);
  375.  
  376. #if 0
  377.     struct    List SemaphoreList;
  378. #endif
  379.  
  380.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "KickMemPtr           = %08X ; ptr to queue of mem lists", s->KickMemPtr);
  381.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "KickTagPtr           = %08X ; ptr to rom tag queue", s->KickTagPtr);
  382.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "KickCheckSum         = %08X ; checksum for mem and tags", s->KickCheckSum);
  383.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "ex_RamLibPrivate     = %08X", s->ex_RamLibPrivate);
  384.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "ex_EClockFrequency   = %08X ; (readable)", s->ex_EClockFrequency);
  385.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "ex_CacheControl      = %08X ; Private to CacheControl calls", s->ex_CacheControl);
  386.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "ex_TaskID            = %08X ; Next available task ID", s->ex_TaskID);
  387.  
  388.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "ex_PuddleSize        = %08X", s->ex_PuddleSize);
  389.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "ex_PoolThreshold     = %08X", s->ex_PoolThreshold);
  390. #if 0
  391.     struct    MinList ex_PublicPool;
  392. #endif
  393.  
  394.     SprintfDLIST(&dp->ds_List, DTYPE_EXECBASE, "ex_MMULock           = %08X ; private", s->ex_MMULock);
  395.  
  396. #if 0
  397.     UBYTE    ex_Reserved[12];
  398. #endif
  399. }
  400.  
  401. void    BuildDLIST(LIST *dst, LIST *src, ULONG type) {
  402.     struct Node    *n;
  403.     char        *ps, *pd, buf[256];
  404.  
  405.     for (n=src->lh_Head; n->ln_Succ; n=n->ln_Succ) {
  406.         if (n->ln_Name) {
  407.             ps = n->ln_Name; pd = &buf[0];
  408.             while (*ps) {
  409.                 if (*ps == 0x0d || *ps == 0x0a) ps++; else *pd++ = *ps++;
  410.             }
  411.             *pd = '\0';
  412.         }
  413.         else
  414.             strcpy(buf, "<NO NAME>");
  415.         SprintfDLIST(dst, type, "%08X %s", n, buf);
  416.     }
  417. }
  418.  
  419. /************************************************************************/
  420.  
  421.  
  422. void    ListResources(DBugDisp *dp) {
  423.     FreeDLIST(&dp->ds_List);
  424.     SprintfDLIST(&dp->ds_List, DTYPE_RESOURCES, "RESOURCE LIST");
  425.     BuildDLIST(&dp->ds_List, &SysBase->ResourceList, DTYPE_RESOURCES);
  426. }
  427.  
  428. void    ListIntrs(DBugDisp *dp) {
  429.     FreeDLIST(&dp->ds_List);
  430.     SprintfDLIST(&dp->ds_List, DTYPE_INTRS, "INTERRUPT LIST");
  431.     BuildDLIST(&dp->ds_List, &SysBase->IntrList, DTYPE_INTRS);
  432. }
  433.  
  434. void    ListPorts(DBugDisp *dp) {
  435.     struct List    *list = &SysBase->PortList;
  436.     short        count;
  437.     struct Node    *n, *n2;
  438.     char        *ps, *pd, buf[256];
  439.     struct MsgPort    *mp;
  440.     static char    *actionTable[] = { "SIGNAL ", "SOFTINT", "IGNORE "};
  441.  
  442.     FreeDLIST(&dp->ds_List);
  443.     SetDisplayMode(DISPLAY_PORTS,0);
  444.     SprintfDLIST(&dp->ds_List, DTYPE_PORTS, "PORTS LIST");
  445.     SprintfDLIST(&dp->ds_List, DTYPE_PORTS, "ADDRESS  ACTION  BIT# TASK     MSGS NAME");
  446.     for (n=list->lh_Head; n->ln_Succ; n=n->ln_Succ) {
  447.         mp = (struct MsgPort *)n;
  448.         if (n->ln_Name) ps = n->ln_Name;
  449.         else ps = "<NO NAME>";
  450.         pd = &buf[0];
  451.         while (*ps) {
  452.             if (*ps == 0x0d || *ps == 0x0a) ps++; else *pd++ = *ps++;
  453.         }
  454.         *pd = '\0';
  455.         // count the number of messages waiting at the port
  456.         for (count=0, n2 = mp->mp_MsgList.lh_Head; n2->ln_Succ; n2=n2->ln_Succ) count++;
  457.         SprintfDLIST(&dp->ds_List, DTYPE_PORTS, "%08X %s  %2d  %08x %4d %s",
  458.             n,
  459.             actionTable[mp->mp_Flags&PF_ACTION],
  460.             (UBYTE)mp->mp_SigBit,
  461.             mp->mp_SigTask,
  462.             count,
  463.             buf
  464.         );
  465.     }
  466. }
  467.  
  468. static char    *stateTable[] = {
  469.     "TS_INVALID",
  470.     "TS_ADDED  ",
  471.     "TS_RUN    ",
  472.     "TS_READY  ",
  473.     "TS_WAIT   ",
  474.     "TS_EXCEPT ",
  475.     "TS_REMOVED",
  476. };
  477.  
  478. void    ListTasks(DBugDisp *dp) {
  479.     struct List    *list;
  480.     short        i;
  481.     struct Node    *n;
  482.     char        *ps, *pd, buf[256];
  483.     struct Task    *t;
  484.  
  485.     FreeDLIST(&dp->ds_List);
  486.     SetDisplayMode(DISPLAY_TASKS,0);
  487.     SprintfDLIST(&dp->ds_List, DTYPE_TASKS, "TASK LIST");
  488.     SprintfDLIST(&dp->ds_List, DTYPE_TASKS, "  ADDRESS  LIST  STATE      SIGNALS NAME");
  489.     for (i=0; i<2; i++) {
  490.         list = i ? &SysBase->TaskWait : &SysBase->TaskReady;
  491.         for (n=list->lh_Head; n->ln_Succ; n=n->ln_Succ) {
  492.             t = (struct Task *)n;
  493.             if (n->ln_Name) ps = n->ln_Name;
  494.             else ps = "<NO NAME>";
  495.             pd = &buf[0];
  496.             while (*ps) {
  497.                 if (*ps == 0x0d || *ps == 0x0a) ps++; else *pd++ = *ps++;
  498.             }
  499.             *pd = '\0';
  500.             SprintfDLIST(&dp->ds_List, DTYPE_TASKS, "%c %08X %s %s %08X  %s",
  501.                 (t == SysBase->ThisTask) ? 0x8d : ' ',
  502.                 n,
  503.                 i ? "WAIT " : "READY",
  504.                 stateTable[t->tc_State],
  505.                 t->tc_SigWait|t->tc_SigExcept,
  506.                 buf
  507.             );
  508.         }
  509.     }
  510.     n = (struct Node *)SysBase->ThisTask;
  511.     t = (struct Task *)n;
  512.     if (n->ln_Name) ps = n->ln_Name;
  513.     else ps = "<NO NAME>";
  514.     pd = &buf[0];
  515.     while (*ps) {
  516.         if (*ps == 0x0d || *ps == 0x0a) ps++; else *pd++ = *ps++;
  517.     }
  518.     *pd = '\0';
  519.     SprintfDLIST(&dp->ds_List, DTYPE_TASKS, "%c %08X %s %s %08X  %s",
  520.         (t == SysBase->ThisTask) ? 0x8d : ' ',
  521.         n,
  522.         i ? "WAIT " : "READY",
  523.         stateTable[t->tc_State],
  524.         t->tc_SigWait|t->tc_SigExcept,
  525.         buf
  526.     );
  527. }
  528.  
  529. void    ListLibs(DBugDisp *dp) {
  530.     struct List    *list = &SysBase->LibList;
  531.     struct Node    *n;
  532.     char        *ps, *pd, buf[256];
  533.     struct Library    *lp;
  534.  
  535.     FreeDLIST(&dp->ds_List);
  536.     SetDisplayMode(DISPLAY_LIBS,0);
  537.     SprintfDLIST(&dp->ds_List, DTYPE_LIBS, "LIBRARY LIST");
  538.     SprintfDLIST(&dp->ds_List, DTYPE_LIBS, "ADDRESS  OPENS VERSION NAME");
  539.     for (n=list->lh_Head; n->ln_Succ; n=n->ln_Succ) {
  540.         lp = (struct Library *)n;
  541.         if (lp->lib_IdString) ps = lp->lib_IdString;
  542.         else if (n->ln_Name) ps = n->ln_Name;
  543.         else ps = "<NO NAME>";
  544.         pd = &buf[0];
  545.         while (*ps) {
  546.             if (*ps == 0x0d || *ps == 0x0a) ps++; else *pd++ = *ps++;
  547.         }
  548.         *pd = '\0';
  549.         SprintfDLIST(&dp->ds_List, DTYPE_LIBS, "%08X %5d %3d.%-3d %s",
  550.             n,
  551.             lp->lib_OpenCnt,
  552.             lp->lib_Version, lp->lib_Revision,
  553.             buf
  554.         );
  555.     }
  556. }
  557.  
  558. void    ListDevices(DBugDisp *dp) {
  559.     struct List    *list = &SysBase->DeviceList;
  560.     struct Node    *n;
  561.     char        *ps, *pd, buf[256];
  562.     struct Library    *lp;
  563.  
  564.     FreeDLIST(&dp->ds_List);
  565.     SetDisplayMode(DISPLAY_DEVICES,0);
  566.     SprintfDLIST(&dp->ds_List, DTYPE_DEVICES, "DEVICE LIST");
  567.     SprintfDLIST(&dp->ds_List, DTYPE_DEVICES, "ADDRESS  OPENS VERSION NAME");
  568.     for (n=list->lh_Head; n->ln_Succ; n=n->ln_Succ) {
  569.         lp = (struct Library *)n;
  570.         if (lp->lib_IdString) ps = lp->lib_IdString;
  571.         else if (n->ln_Name) ps = n->ln_Name;
  572.         else ps = "<NO NAME>";
  573.         pd = &buf[0];
  574.         while (*ps) {
  575.             if (*ps == 0x0d || *ps == 0x0a) ps++; else *pd++ = *ps++;
  576.         }
  577.         *pd = '\0';
  578.         SprintfDLIST(&dp->ds_List, DTYPE_DEVICES, "%08X %5d %3d.%-3d %s",
  579.             n,
  580.             lp->lib_OpenCnt,
  581.             lp->lib_Version, lp->lib_Revision,
  582.             buf
  583.         );
  584.     }
  585. }
  586.  
  587. void    ListMemList(DBugDisp *dp) {
  588.     struct List        *list = &SysBase->MemList;
  589.     struct Node        *n;
  590.     char            *ps, *pd, buf[256];
  591.     struct MemHeader    *mh;
  592.     struct MemChunk     *mc;
  593.     ULONG            largest, count;
  594.  
  595.     FreeDLIST(&dp->ds_List);
  596.     dp->ds_DisplayMode = DISPLAY_MEMLIST;
  597.     SetDisplayMode(DISPLAY_MEMLIST,0);
  598.     SprintfDLIST(&dp->ds_List, DTYPE_MEMLIST, "MEMORY LIST");
  599.     for (n=list->lh_Head; n->ln_Succ; n=n->ln_Succ) {
  600.         if (n->ln_Name) {
  601.             ps = n->ln_Name; pd = &buf[0];
  602.             while (*ps) {
  603.                 if (*ps == 0x0d || *ps == 0x0a) ps++; else *pd++ = *ps++;
  604.             }
  605.             *pd = '\0';
  606.         }
  607.         else
  608.             strcpy(buf, "<NO NAME>");
  609.         mh = (struct MemHeader *)n;
  610.         SprintfDLIST(&dp->ds_List, DTYPE_MEMLIST, "$%08X %08X-%08X %d %s",
  611.             n,
  612.             mh->mh_Lower,
  613.             mh->mh_Upper,
  614.             mh->mh_Free,
  615.             buf
  616.         );
  617.         strcpy(buf, "");
  618.         if (mh->mh_Attributes & MEMF_PUBLIC) strcat(buf, "MEMF_PUBLIC ");
  619.         if (mh->mh_Attributes & MEMF_CHIP) strcat(buf, "MEMF_CHIP ");
  620.         if (mh->mh_Attributes & MEMF_FAST) strcat(buf, "MEMF_FAST ");
  621.         if (mh->mh_Attributes & MEMF_LOCAL) strcat(buf, "MEMF_LOCAL ");
  622.         if (mh->mh_Attributes & MEMF_24BITDMA) strcat(buf, "MEMF_24BITDMA ");
  623.         SprintfDLIST(&dp->ds_List, DTYPE_MEMLIST, "  Satisfies %s", buf);
  624.  
  625.         largest = 0; count = 0;
  626.         for (mc = mh->mh_First; mc; mc = mc->mc_Next) {
  627.             count++;
  628.             if (mc->mc_Bytes > largest) largest = mc->mc_Bytes;
  629.         }
  630.         SprintfDLIST(&dp->ds_List, DTYPE_MEMLIST, "  %d fragments, largest is %d bytes ", count, largest);
  631.     }
  632. }
  633. #if 0
  634. Local int my_comp(char **s1, char **s2);
  635. int my_comp(char **s1, char **s2) {
  636.       return(strcmp(*s1, *s2));
  637. }
  638. #endif
  639.  
  640. Local int my_comp(SYMLIST **arg1, SYMLIST **arg2);
  641. int int my_comp(SYMLIST **arg1, SYMLIST **arg2)
  642. {
  643. ULONG *s1, *s2, len1, len2;
  644.  
  645. s1 = ((SYMLIST *)arg1)[0].symbolname;
  646. s2 = ((SYMLIST *)arg2)[0].symbolname;
  647.  
  648. len1 = 4 * (*s1++);
  649. len2 = 4 * (*s2++);
  650.  
  651.     if(len2 < len1)return -strncmp((char *)s2,(char *)s1,len2);
  652.     return strncmp((char *)s1,(char *)s2,len1);
  653. }
  654.  
  655. // Build a sorted Symbol List
  656. BOOL    ListSymbols(DBugDisp *dp) {
  657.     LIST        *lp = &dp->ds_List;
  658.     int i, len, symcount = CountSymbols();
  659.     SYMLIST *symbols;
  660.     char buffer[128];
  661.     ULONG *name;
  662.  
  663.     if((symbols= malloc(symcount * sizeof(SYMLIST)))) {
  664.     FreeDLIST(lp);
  665.     SetDisplayMode(DISPLAY_SYMLIST,0);
  666.     CopySymbols(symbols);
  667.  
  668.     qsort(symbols, symcount, sizeof(SYMLIST), my_comp);
  669.     SprintfDLIST(lp, DTYPE_SYMLIST, "SORTED SYMBOL LIST");
  670.         for (i = 0; i < symcount; ++i) {
  671.         name = symbols[i].symbolname;
  672.         len = *name++;
  673.         memset(buffer,0,128);
  674.         strncpy(buffer,(char *)name,4*len);
  675.         SprintfDLIST(lp, DTYPE_SYMLIST, "%08X %-16.16s", symbols[i].address, buffer);
  676.     }
  677.     free(symbols);
  678.     }
  679. }
  680.